package admin_admin

import (
	"gitee.com/theegg/go-brick/app/controller/admin_api"
	"gitee.com/theegg/go-brick/app/model/admin/admin_permissions"
	"gitee.com/theegg/go-brick/app/model/admin/admin_users"
	"gitee.com/theegg/go-brick/app/model/system/system_images"
	"gitee.com/theegg/go-brick/app/service/app"
	"gitee.com/theegg/go-brick/app/service/help/cmap"
	"gitee.com/theegg/go-brick/app/service/help/cstruct"
	"github.com/gin-gonic/gin"
	"strconv"
)

// @title 用户列表
func AdminUserList(c *gin.Context) {
	// 检验参数
	var validaParams admin_users.AdminUsersQueryParams
	if errCheck := c.ShouldBind(&validaParams); errCheck != nil {
		app.NewResponse(c).JsonReturn(false, app.NewError(errCheck).Error(), nil)
		return
	}

	adminUser, err := admin_api.GetLoginAdminUser(c)
	if err != nil {
		c.AbortWithStatus(401)
		return
	}

	// 获取自身的roleID
	role, errRole := adminUser.Role()
	if errRole != nil {
		app.NewResponse(c).JsonReturn(false, app.NewError(errRole).Error(), nil)
		return
	}

	// 获取数据
	data, err := admin_users.GetDataList(cstruct.StructToMap(validaParams), *role)
	if err != nil {
		app.NewResponse(c).JsonReturn(false, app.NewError(err).Error(), nil)
		return
	}

	// 1. 当前管理员可以分配的角色
	childRoleOption, errOption := role.GetChildRoleOption(true)
	if errOption != nil {
		app.NewResponse(c).JsonReturn(false, app.NewError(errOption).Error(), nil)
		return
	}

	data["role_option"] = childRoleOption

	app.NewResponse(c).JsonReturn(true, "获取数据成功", data)
	return
}

// @title 添加管理用户
// @description 添加用户和编辑用户是一个流程
func AdminUserAdd(c *gin.Context) {
	adminUserModel := new(admin_users.AdminUsers)
	var validaParams admin_users.AdminUsersAddParams
	if err := c.ShouldBind(&validaParams); err != nil {
		app.NewResponse(c).JsonReturn(false, "bind-json-"+err.Error(), nil)
		return
	}

	//  当前登陆用户
	CurrentAdminUser, err := admin_api.GetLoginAdminUser(c)
	if err != nil {
		app.NewResponse(c).JsonReturn(false, "对不起, 用户未登陆", nil)
		return
	}

	validaParams.Ip = c.ClientIP()
	adminUser, err := adminUserModel.AddAdminUser(validaParams, CurrentAdminUser)
	if err != nil {
		app.NewResponse(c).JsonReturn(false, err.Error(), adminUser)
		return
	}

	app.NewResponse(c).JsonReturn(true, "添加数据成功", adminUser)
	return
}

// @title AdminUserAvatarUpload
// @description 上传用户头像
func AdminUserAvatarUpload(c *gin.Context) {
	imageName, errUpload := system_images.SaveImage("admin_user", "avatar", c)
	if errUpload != nil {
		app.NewResponse(c).JsonReturn(false, errUpload.Error(), nil)
		return
	}

	returnData := make(map[string]interface{})
	returnData["file_url"] = app.GetImageStaticUrl(imageName)
	returnData["file_name"] = imageName

	app.NewResponse(c).JsonReturn(true, "上传图片成功!", returnData)
	return
}

// @title AdminUserSetting
// @description 用户设置
func AdminUserSetting(c *gin.Context) {
	targetUser, err := getTargetAdminUserFromParams(c)
	if err != nil {
		app.NewResponse(c).JsonReturn(false, err.Error(), nil)
		return
	}

	action := c.PostForm("action")
	if action == "" || action == "login" {
		var validaParams admin_users.AdminUserLoginPasswordParams
		if err := c.ShouldBind(&validaParams); err != nil {
			app.NewResponse(c).JsonReturn(false, "bind-json-"+err.Error(), nil)
			return
		}

		if validaParams.Password != validaParams.ConfirmPassword {
			app.NewResponse(c).JsonReturn(false, "对不起, 两次密码输入不正确!", nil)
			return
		}

		// 执行修改
		res, errModify := targetUser.ModifyLoginPassword(validaParams)
		if errModify != nil {
			app.NewResponse(c).JsonReturn(false, app.NewError(errModify).Error(), nil)
			return
		}

		if !res {
			app.NewResponse(c).JsonReturn(false, "对不起, 修改管理员登陆密码失败", nil)
			return
		}

		app.NewResponse(c).JsonReturn(true, "恭喜, 修改管理员登陆密码成功.", nil)
	} else if action == "sec" {
		var validaParams admin_users.AdminUserSecPasswordParams
		if err := c.ShouldBind(&validaParams); err != nil {
			app.NewResponse(c).JsonReturn(false, "bind-json-"+err.Error(), nil)
			return
		}

		if validaParams.SecPassword != validaParams.ConfirmSecPassword {
			app.NewResponse(c).JsonReturn(false, "对不起, 两次密码输入不正确!", nil)
			return
		}

		// 执行修改
		res, errModify := targetUser.ModifySecPassword(validaParams)
		if errModify != nil {
			app.NewResponse(c).JsonReturn(false, app.NewError(errModify).Error(), nil)
			return
		}

		if !res {
			app.NewResponse(c).JsonReturn(false, "对不起, 修改管理员安全密码失败", nil)
			return
		}

		app.NewResponse(c).JsonReturn(true, "恭喜, 修改管理员安全密码成功.", nil)
	} else if action == "info" {
		var validaParams admin_users.AdminUserBaseInfoParams
		if err := c.ShouldBind(&validaParams); err != nil {
			app.NewResponse(c).JsonReturn(false, "bind-json-"+err.Error(), nil)
			return
		}

		// 执行修改
		res, errModify := targetUser.ModifyBaseInfo(validaParams)
		if errModify != nil {
			app.NewResponse(c).JsonReturn(false, app.NewError(errModify).Error(), nil)
			return
		}

		if !res {
			app.NewResponse(c).JsonReturn(false, "对不起, 修改管理员基本信息失败", nil)
			return
		}

		app.NewResponse(c).JsonReturn(true, "恭喜, 修改管理员基本信息成功.", nil)
	}
	return
}

// @title 删除用户
// @description 删除用户, 需要用户状态为禁用状态, 并且删除所有的用户帮顶的角色和权限
func AdminUserDel(c *gin.Context) {
	targetUser, err := getTargetAdminUserFromParams(c)
	if err != nil {
		app.NewResponse(c).JsonReturn(false, err.Error(), nil)
		return
	}

	// 启用状态的用户无法删除
	if targetUser.Status == 1 {
		app.NewResponse(c).JsonReturn(false, "对不起，请先禁用目标管理员.", nil)
		return
	}

	// 删除
	_, errDel := admin_users.DeleteUserById(targetUser.Id)
	if errDel != nil {
		app.NewResponse(c).JsonReturn(false, errDel.Error(), nil)
		return
	}

	app.NewResponse(c).JsonReturn(true, "恭喜, 删除管理员成功.", nil)
	return
}

// 修改状态
func AdminUserStatus(c *gin.Context) {
	targetUser, err := getTargetAdminUserFromParams(c)
	if err != nil {
		app.NewResponse(c).JsonReturn(false, err.Error(), nil)
		return
	}

	ok, errModify := targetUser.ModifyStatus()
	if errModify != nil {
		app.NewResponse(c).JsonReturn(false, errModify.Error(), nil)
		return
	}

	if !ok {
		app.NewResponse(c).JsonReturn(false, "对不起, 修改管理员失败, 请联系客服", nil)
		return
	}

	app.NewResponse(c).JsonReturn(true, "恭喜, 修改管理员状态成功", nil)
	return
}

// @title AdminUserGetPermissions
// @description 获取 当前 登陆用户 / 目标用户 分配的权限
func AdminUserGetPermissions(c *gin.Context) {
	// 1. 通过params  检测
	targetUser, err := getTargetAdminUserFromParams(c)
	if err != nil {
		app.NewResponse(c).JsonReturn(false, err.Error(), nil)
		return
	}

	// 2. 当前登陆用户
	CurrentAdminUser, err := admin_api.GetLoginAdminUser(c)
	if err != nil {
		app.NewResponse(c).JsonReturn(false, "对不起, 用户未登陆", nil)
		return
	}

	// 3. 是否为下级
	ok, errHas := CurrentAdminUser.HaveChild(targetUser.Id)
	if errHas != nil {
		app.NewResponse(c).JsonReturn(false, errHas.Error(), nil)
		return
	}

	if !ok {
		app.NewResponse(c).JsonReturn(false, "对不起, 您没有权限!", nil)
		return
	}

	// 4. 当前角色 分配的权限ID
	currentPermissions, err := CurrentAdminUser.Permissions()
	if err != nil {
		app.NewResponse(c).JsonReturn(false, "对不起，获取当前用户权限失败!", nil)
	}

	// 5. 目标用户 拥有的权限ID
	targetPermissions, errTarget := targetUser.HelpPermissionToKey()
	if errTarget != nil {
		app.NewResponse(c).JsonReturn(false, "对不起，获取当前用户权限失败!", nil)
		return
	}

	// 6. 目标角色　拥有的权限ID :: 如果角色已经拥有了权限，那么不需要在指定给用户了
	targetRole, errTargetRole := targetUser.Role()
	if errTargetRole != nil {
		app.NewResponse(c).JsonReturn(false, "对不起，目标用户角色不存在!", nil)
		return
	}

	targetRolePermissions, errTrp := targetRole.HelpPermissionToKK()
	if errTrp != nil {
		app.NewResponse(c).JsonReturn(false, "对不起，获取目标用户角色权限失败!", nil)
		return
	}

	canSendPermissions := make(map[int64]*admin_permissions.AdminPermissions)
	for ci, cItem := range currentPermissions {
		if _, ok := targetRolePermissions[ci]; !ok {
			canSendPermissions[ci] = cItem
		}
	}

	currentPermissionsTree := admin_permissions.BuildPermissionTree(canSendPermissions, 0)

	returnData := make(map[string]interface{})
	returnData["current_permissions"] = currentPermissionsTree
	returnData["checked_permissions"] = targetPermissions

	app.NewResponse(c).JsonReturn(true, "恭喜, 获取用户权限数据成功", returnData)
	return
}

// @title AdminUserEditPermissions
// @description 编辑 当前 登陆用户 / 目标用户 分配的权限
func AdminUserEditPermissions(c *gin.Context) {
	// 1. 通过params  检测
	targetUser, err := GetTargetAdminUserFromParams(c)
	if err != nil {
		app.NewResponse(c).JsonReturn(false, err.Error(), nil)
		return
	}

	// 2. 获取传递的参数 permission ids 并转成map[int64]int64
	checkedPermissionStrMapIds := c.PostFormMap("data")
	checkedPermissionInt64MapIds, errTrans := cmap.StringMapToInt64Map(checkedPermissionStrMapIds)
	if errTrans != nil {
		app.NewResponse(c).JsonReturn(false, errTrans.Error(), nil)
		return
	}

	// 3 - 1. 当前登陆用户
	CurrentAdminUser, err := admin_api.GetLoginAdminUser(c)
	if err != nil {
		app.NewResponse(c).JsonReturn(false, "对不起, 用户未登陆", nil)
		return
	}

	// 3 - 2. 编辑
	ok, errEdit := CurrentAdminUser.EditUserPermissions(targetUser, checkedPermissionInt64MapIds)
	if errEdit != nil {
		app.NewResponse(c).JsonReturn(false, errEdit.Error(), nil)
		return
	}

	// 4. 判断是否编辑成功
	if !ok {
		app.NewResponse(c).JsonReturn(false, "对不起, 编辑菜单失败", nil)
		return
	}

	app.NewResponse(c).JsonReturn(true, "恭喜, 编辑菜单成功", nil)
	return
}

/** ==========================  help 函数 ============================= */

// @title getTargetAdminUserFromParams
// @description 内置方法　通过参数id获取目标对象, 验证当前登陆用户是否可以操作目标用户
func getTargetAdminUserFromParams(c *gin.Context) (*admin_users.AdminUsers, error) {
	id := c.PostForm("id")
	if id == "" {
		return nil, app.NewError("对不起, 管理员ID不能为空")
	}

	int64Id, errConv := strconv.ParseInt(id, 10, 64)
	if errConv != nil {
		return nil, app.NewError("对不起, 目标用户ID格式不正确")
	}

	// 获取用户
	targetUser, errTarget := admin_users.GetItemFromCacheById(int64Id)
	if errTarget != nil {
		return nil, app.NewError(errTarget)
	}

	// 判定当前登陆用户是否存在
	currentAdminUser, errCurrent := admin_api.GetLoginAdminUser(c)
	if errCurrent != nil {
		return nil, app.NewError(errCurrent)
	}

	// 判定目标用户是否当强登陆用户下级
	ok, errChild := currentAdminUser.HaveChild(targetUser.Id)
	if errChild != nil {
		return nil, app.NewError(errChild)
	}

	if !ok {
		return nil, app.NewError("对不起, 您不具有修改目标用户密码的权限!")
	}

	return targetUser, nil
}
